/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "pch.h"
#include "词法.h"

#include <字符串/str_分割.h>
#include <字符串数值互换.h>
#include <字符串转换.h>
#include <几何数据.h>

//#include "LLVM/LLVM_JIT.h"
#include "解析运算符.h"

static std::map<E_基础类型, std::u16string> g基础类型;
static std::map<std::u16string, E_基础类型> g基础类型名称;


//栈上变量空间的分配，AllocaInst语句
//StoreInst 堆上分配空间
uint32 a = 0;
uint32 b = a += a;


static std::wstring f_截取到字符串代码(std::wstring& 源代码, const std::wstring& 查找字符, uint32 删除补偿) {
	auto pos = 源代码.find(查找字符);
	if (std::wstring::npos != pos) {
		auto substr = 源代码.substr(0, pos);

		源代码.erase(0, pos + 删除补偿);
		return substr;
	}
	
	return L"";
}


E_值类型 f_变量类型解析(const std::wstring& 数据类型关键字) {
	std::wstring err;

	int64 init_value;
	E_值类型 type;
	if (数据类型关键字 == L"int8") {
		type = E_值类型::e_Type_I8;
		//变量代码 = f_变量代码提取(空格分割后代码, L";");
	}
	else if (数据类型关键字 == L"int16") {
		type = E_值类型::e_Type_I16;
		//变量代码 = f_变量代码提取(空格分割后代码, L";");
	}
	else if (数据类型关键字 == L"int32") {
		type = E_值类型::e_Type_I32;
		//变量代码 = f_变量代码提取(空格分割后代码, L";");
	}
	else if (数据类型关键字 == L"int64") {
		//变量代码 = f_变量代码提取(空格分割后代码, L";");
	}
	else if (数据类型关键字 == L"int128") {
		
	}

	else if (数据类型关键字 == L"uint8") {

	}
	else if (数据类型关键字 == L"uint16") {

	}
	else if (数据类型关键字 == L"uint32") {

	}
	else if (数据类型关键字 == L"uint64") {

	}
	else if (数据类型关键字 == L"uint128") {

	}

	else if (数据类型关键字 == L"float16") {

	}
	else if (数据类型关键字 == L"float32") {

	}
	else if (数据类型关键字 == L"float64") {

	}
	else if (数据类型关键字 == L"float128") {

	}
	else {
		type = E_值类型::e_Type_End;
	}

	return type;
}




static std::vector<llvm::Value*> f_构建没有括号的表达式IR(std::wstring 表达式代码, C_程序树& 程序树) {
	uint32 i = 0;
	std::vector<llvm::Value*> 操作数;

	auto 运算符 = f_get表达式符号和标示(表达式代码, E_运算符优先级::e_运算符_L0);
	if (运算符.size()) {
		for (auto& e : 运算符) {
			if (e.操作符名称.empty() == false) {
				//auto 结果 = f_llvm_构建算术运算符L1IR(程序树.m_变量[e.操作符名称], E_运算符优先级(e.操作符枚举));
				//操作数.push_back(结果);
			}
		}
		return 操作数;
	}

	运算符 = f_get表达式符号和标示(表达式代码, E_运算符优先级::e_运算符_L1);
	if (运算符.size()) {
		for (auto& e : 运算符) {
			if (e.操作符名称.empty() == false) {
				//auto 结果 = f_llvm_构建算术运算符L1IR(程序树.m_变量[e.操作符名称], E_运算符优先级(e.操作符枚举));
				//操作数.push_back(结果);
			}


			return 操作数;
		}
	}

	运算符 = f_get表达式符号和标示(表达式代码, E_运算符优先级::e_运算符_L2);
	if (运算符.size()) {
		for (auto& e : 运算符) {
			if (e.操作符名称.empty() == false) {
				//auto 结果 = f_llvm_构建算术运算符L1IR(程序树.m_变量[e.操作符名称], E_运算符优先级(e.操作符枚举));
				//操作数.push_back(结果);
			}
		}
		return 操作数;
	}

	运算符 = f_get表达式符号和标示(表达式代码, E_运算符优先级::e_运算符_L3);
	if (运算符.size()) {
		for (auto& e : 运算符) {
			if (e.操作符名称.empty() == false) {
				//auto 结果 = f_llvm_构建算术运算符L1IR(程序树.m_变量[e.操作符名称], E_运算符优先级(e.操作符枚举));
				//操作数.push_back(结果);
			}
		}
		return 操作数;
	}

	运算符 = f_get表达式符号和标示(表达式代码, E_运算符优先级::e_运算符_L4);
	if (运算符.size()) {
		for (auto& e : 运算符) {
			if (e.操作符名称.empty() == false) {
				auto 结果 = f_llvm_构建乘除运算符IR(程序树.m_变量[e.操作符名称], 程序树.m_变量[e.操作符名称], e.操作符枚举);
				操作数.push_back(结果);
			}
		}
		return 操作数;
	}

	运算符 = f_get表达式符号和标示(表达式代码, E_运算符优先级::e_运算符_L5);
	if (运算符.size()) {
		for (auto& e : 运算符) {
			if (e.操作符名称.empty() == false) {
				auto 结果 = f_llvm_构建加减运算符IR(程序树.m_变量[e.操作符名称], 程序树.m_变量[e.操作符名称], e.操作符枚举);
				操作数.push_back(结果);
			}
		}
		return 操作数;
	}


	运算符 = f_get表达式符号和标示(表达式代码, E_运算符优先级::e_运算符_L6);
	if (运算符.size()) {
		uint32 num = 运算符.size();
		for (auto& e : 运算符) {
			if (e.操作符名称.empty() == false) {
				auto 结果 = f_llvm_构建位移运算符IR(程序树.m_变量[e.操作符名称], 程序树.m_变量[e.操作符名称], e.操作符枚举);
				操作数.push_back(结果);
			}
			++i;
		}
		return 操作数;
	}


	运算符 = f_get表达式符号和标示(表达式代码, E_运算符优先级::e_运算符_L15);
	if (运算符.size()) {
		uint32 num = 运算符.size() - 1;

		for (uint32 i = 0; i < num; ++i) {
			运算符[i];
			运算符[i + 1];
		}
		for (auto& e : 运算符) {
			if (e.操作符名称.empty() == false) {
				auto 结果 = f_llvm_构建赋值运算符IR(程序树.m_变量[e.操作符名称], 程序树.m_变量[e.操作符名称], e.操作符枚举);
				操作数.push_back(结果);
			}
			++i;
		}
		return 操作数;
	}

	return {};
	
}


bool f_变量代码解析(std::wstring& 变量代码, E_值类型 type, bool 是否为常量, C_程序树& 程序树) {
	std::wstring err;

	int64 init_value;
	
	if (type != E_值类型::e_Type_None) {
		//f_构建没有括号的表达式IR(变量代码, 程序树);
		auto 等式两边 = f_str_分割(变量代码, L"=");

		//是否有初始化
		if (等式两边[1].size()) {
			auto 初始化值 = f_构建没有括号的表达式IR(等式两边[1], 程序树);
			init_value = f_字符串转I32(等式两边[1]);
		}
		else {
			err = (L"int32 常量没有初始值");
		}

		auto 多个变量名称 = f_str_分割(等式两边[0], L",");
		for (auto& e : 多个变量名称) {
			//e.substr(e.find_first_not_of(' '), e.find_last_not_of(' ') + 1);
			if (是否为常量) {
				auto v = f_llvm_构建i32常量(f_llvm_构建环境(), init_value);
				程序树.m_常量[e] = v;
			}
			else {
				auto v = f_llvm_构建变量(f_llvm_构建环境(), 程序树.m_块.pBlock, type, init_value, "u");
				程序树.m_变量[e] = v;
			}
		}

		return true;
	}

	return false;
}



bool f_全局变量代码解析(std::wstring 变量代码, E_值类型 type, bool 是否为常量, C_程序树& 程序集) {
	std::wstring err;

	int64 init_value;

	if (type != E_值类型::e_Type_None) {
		auto 等式两边 = f_str_分割(变量代码, L"=");
		
		if (等式两边[1].size()) {
			init_value = f_字符串转I32(等式两边[1]);
		}
		else {
			err = (L"int32 常量没有初始值");
		}

		auto 多个变量名称 = f_str_分割(等式两边[0], L",");
		for (auto& e : 多个变量名称) {
			//e.erase(e.substr(e.find_first_not_of(' '), e.find_last_not_of(' ') + 1));
			e.erase(0, e.find_first_not_of(' '));
			e.erase(e.find_last_not_of(' ') + 1);
			//int32 a, c,d ,f, e , afds,b=100;

			if (是否为常量) {
				auto v = f_llvm_构建i32常量(f_llvm_构建环境(), init_value);
				程序集.m_常量[e] = v;
			}
			else {
				auto v = f_llvm_构建变量(f_llvm_构建环境(), nullptr, type, init_value, "u");
				程序集.m_变量[e] = v;
			}
		}

		return true;
	}

	return false;
}





static bool f_无括号表达式代码解析(std::wstring& 表达式代码, C_程序树& 程序树) {
	auto 空格前面词 = f_str_取到字符(表达式代码, L" ");


	//解析括号运算符
	if (空格前面词.size()) {
		//变量的定义
		bool 是否为常量 = false;

		if (空格前面词 == L"return") {
			auto 返回变量 = f_str_取到字符(表达式代码, L";");
		}
		else {
			std::wstring 类型关键字;
			if (空格前面词 == L"const") {
				表达式代码.erase(0, 空格前面词.size());
				类型关键字 = f_str_取到字符(表达式代码, L" ");
				是否为常量 = true;
			}
			else {
				类型关键字 = 空格前面词;
			}

			auto var_type = f_变量类型解析(类型关键字);
			if (var_type != E_值类型::e_Type_End || 程序树.m_类型声明.find(空格前面词) != 程序树.m_类型声明.end()) {
				//先去掉字符串中的类型关键字
				表达式代码.erase(0, 空格前面词.size());

				f_变量代码解析(表达式代码, var_type, 是否为常量, 程序树);
			}
			else {
				goto To_表达式构建;
			}
		}

	}
	else {
	To_表达式构建:
		空格前面词 = 表达式代码;
		f_str_删除两头字符(空格前面词, L" ");

		//分支循环解析
		if (空格前面词 == L"if") {

		}
		else if (空格前面词 == L"else") {

		}
		else if (空格前面词 == L"for") {

		}
		else if (空格前面词 == L"switch") {

		}
		else {
			//表达式解析
			auto 每段代码 = f_str_分割(表达式代码, L";");
			for (auto& 行 : 每段代码) {
				f_构建没有括号的表达式IR(行, 程序树);
			}

		}
	}

	return false;
}


static bool f_有括号表达式代码解析(std::wstring& 表达式代码, C_程序树& 程序树, S_括号代码块& 表达式块, range_2 上一层区间) {
	uint32 num = 表达式块.块.size();

	//auto 表达式 = f_表达式解析赋值运算符(表达式代码);
	//auto 表达式 = f_括号表达式解析(表达式代码);
	//for (uint32 i = 0; i < num; ++i) {
	//}
	auto 括号前面字符串 = 表达式代码.substr(上一层区间.begin, 表达式块.符.字符串位置begin);
	//auto 括号后面字符串 = 表达式代码.substr(表达式块.符.字符串位置end, 上一层区间.end);


	f_无括号表达式代码解析(括号前面字符串, 程序树);
	

	

	
	
	if (num) {
		bool 没有子嵌套 = true;

		auto* data = 表达式块.块.data();
		for (uint32 i = 0; i < num; ++i) {
			range_2 当前层区间 = { data[i].符.字符串位置begin, data[i].符.字符串位置end };
			if (当前层区间.end - 当前层区间.begin != 0) {
				f_有括号表达式代码解析(表达式代码, 程序树, data[i], 当前层区间);
				没有子嵌套 = false;
			}
		}

		if (没有子嵌套) {
			//f_有括号表达式代码解析(表达式代码, 程序树, {}, {});
			auto 括号内文本 = 表达式代码.substr(表达式块.符.字符串位置begin+1, 表达式块.符.字符串位置end - 表达式块.符.字符串位置begin - 2);
			f_无括号表达式代码解析(括号内文本, 程序树);
		}
	}
	else {

	}
	

	return false;
}


static bool f_函数代码解析(std::wstring& 表达式代码, C_程序树& 程序树) {
	std::wstring 函数代码;

	程序树.m_函数名称 = f_截取到字符串代码(表达式代码, L"(", 0);
	if (程序树.m_函数名称.empty()) {
		//err
	}
	else {
		f_str_删除两头字符(程序树.m_函数名称, L" ");

		auto 参数和返回 = f_截取到字符串代码(表达式代码, L"{", 0);
		auto 参数和返回分割 = f_str_分割(参数和返回, L"->");

		//返回类型
		if (参数和返回分割.size() > 1) {
			f_str_删除两头字符(参数和返回分割[1], L" ");
			auto var_type = f_变量类型解析(参数和返回分割[1]);
			std::string name;
			if (var_type != E_值类型::e_Type_End) {
				程序树.m_返回类型 = f_llvm_构建类型(f_llvm_构建环境(), var_type, name);
			}
			else {
				
				//程序树.m_返回类型 = f_llvm_构建类型(f_llvm_构建环境(), var_type, name);
			}
		}
		程序树.m_返回类型 = llvm::Type::getFloatTy(f_llvm_构建环境());

		//参数分解
		f_str_删除两头字符(参数和返回分割[0], L"(", L")");
		auto 每个参数 = f_str_分割(参数和返回分割[0], L",");
		for (uint32 i = 0; i < 每个参数.size(); ++i) {
			//S_括号代码块 参数括号 = f_括号表达式解析(每个参数[i]);
			
			f_str_删除两头字符(每个参数[i], L" ");

			auto type = f_截取到字符串代码(每个参数[i], L" ", 1);
			bool 是否输入 = false;
			if (type == L"in") {
				type = f_截取到字符串代码(每个参数[i], L" ", 1);
				是否输入 = true;
			}else if (type == L"out") {
				type = f_截取到字符串代码(每个参数[i], L" ", 1);
			}

			auto 名称和初始值 = f_str_分割(每个参数[i], L"=");
			if (名称和初始值.size() > 1) {

			}

			f_str_删除两头字符(名称和初始值[0], L" ");
			//auto 类型和名称 = f_str_分割(名称和初始值[0], L" ");
			auto var_type = f_变量类型解析(type);
			//auto var_name = f_变量类型解析(类型和名称[0]);
			if (var_type != E_值类型::e_Type_End) {
				std::string name;
				程序树.m_参数.push_back(f_llvm_构建类型(f_llvm_构建环境(), var_type, name));
				if (是否输入) {
					程序树.m_in参数类型.push_back({ var_type,  名称和初始值[0] });
				}
				else {
					程序树.m_out参数类型.push_back({ var_type,  名称和初始值[0] });
				}
			}
		}
		

		S_括号代码块 函数实现 = f_括号表达式解析(表达式代码);


		auto funcName = f_WStringToString(程序树.m_函数名称);
		程序树.m_块 = f_llvm_构建函数声明(funcName, 程序树.m_参数, llvm::Type::getVoidTy(f_llvm_构建环境()), false);

		f_有括号表达式代码解析(表达式代码, 程序树, 函数实现, { 0, uint32(表达式代码.size()) });
		表达式代码.erase(函数实现.符.字符串位置begin, 函数实现.符.字符串位置end - 函数实现.符.字符串位置begin + 1);

		llvm::Value* pV1 = llvm::ConstantFP::get(f_llvm_构建环境(), llvm::APFloat(1.01));
		//f_llvm_构建返回值(程序树.m_块, 程序树.m_变量[], funcName);
	}

	return false;
}





C_程序代码::C_程序代码() {
}

C_程序代码::~C_程序代码() {
}


void C_程序代码::f_Load代码(const std::wstring& code) {
	//auto 空格分割后代码 = f_str_分割(code, L" ");
	//if (空格分割后代码.empty()) 空格分割后代码 = { code };
	std::wstring err;
	auto 待解析代码 = code;


	for (;;) {
		if (待解析代码.size() == 0) break;

		uint64 pos = 待解析代码.find(' ');
		if (pos >= std::wstring::npos) {
			//auto 表达式代码 = f_截取到字符串代码(空格分割后代码, L";");
			auto 表达式块 = f_括号表达式解析(待解析代码);
			auto 表达式 = f_有括号表达式代码解析(待解析代码, m_程序树, 表达式块, {0, uint32(待解析代码.size()) });
			
		}
		else {
			//auto c = 空格分割后代码.front();
			auto c = 待解析代码.substr(0, pos);
			待解析代码.erase(0, pos);



			//============================= 声明关键字部分 ============================
			bool 是否为常量 = false;
			if (c == L"fu") {
				C_程序树* tree = new C_程序树();
				//空格分割后代码.erase(空格分割后代码.begin());
				f_函数代码解析(待解析代码, *tree);
				m_程序树.m_子树[tree->m_函数名称] = tree;
				//goto To_移除第一个;
			}
			else if (c == L"const") {
				是否为常量 = true;
				待解析代码.erase(待解析代码.begin());

				goto To_变量解析;
			}
			else if (c == L"struct") {
				待解析代码.erase(待解析代码.begin());
			}
			else {
			To_变量解析:
				auto val_type = f_变量类型解析(c);

				
				//std::vector<std::wstring> 变量代码 = f_截取到字符串代码(空格分割后代码, L";");
				if (E_值类型::e_Type_None != E_值类型::e_Type_End) {
					auto 变量代码 = f_截取到字符串代码(待解析代码, L";", 1);
					bool 是否构建变量成功 = f_全局变量代码解析(变量代码, val_type, 是否为常量, m_程序树);
				}
				else {

				}

				if (err.empty() == false) break;
			}
		}

		//if (空格分割后代码.size()) 空格分割后代码.erase(空格分割后代码.begin());

	//To_移除第一个:
	//	空格分割后代码.erase(空格分割后代码.begin());
	}

	m_Err.push_back(err);

}

void C_程序代码::f_close代码()
{

}

void C_程序代码::f_编译()
{
}

void C_程序代码::f_解析代码()
{
}



#include "编译错误信息.h"
#include "函数代码解析.h"
#include "结构代码解析.h"
#include "变量代码解析.h"
#include "代码模块.h"

static std::map<std::u16string, S_代码模块> g导入模块;


//static std::map<E_代码块类型, std::u16string> g代码块;
static std::map<std::u16string, S_变量代码块> g变量代码块;
static std::map<std::u16string, S_函数代码块> g函数代码块;
static std::map<std::u16string, S_结构代码块> g结构代码块;
static std::map<std::u16string, S_函数声明代码>	g虚函数代码块;
static std::map<std::u16string, S_成员函数代码块>	g成员函数代码块;

static std::map<std::u16string, S_导出模块> g代码导出模块;

static std::set<std::u16string> g以声明结构类型;



void f_code_解析器初始化() {
	g基础类型名称[u"i8"] = E_基础类型::e_i8;
	g基础类型名称[u"u8"] = E_基础类型::e_u8;
	g基础类型名称[u"i16"] = E_基础类型::e_i16;
	g基础类型名称[u"u16"] = E_基础类型::e_u16;
	g基础类型名称[u"i32"] = E_基础类型::e_i32;
	g基础类型名称[u"u32"] = E_基础类型::e_u32;
	g基础类型名称[u"i64"] = E_基础类型::e_i64;
	g基础类型名称[u"u64"] = E_基础类型::e_u64;
	g基础类型名称[u"i128"] = E_基础类型::e_i128;
	g基础类型名称[u"u128"] = E_基础类型::e_u128;
	g基础类型名称[u"f16"] = E_基础类型::e_f16;
	g基础类型名称[u"f32"] = E_基础类型::e_f32;
	g基础类型名称[u"f64"] = E_基础类型::e_f64;
	g基础类型名称[u"f128"] = E_基础类型::e_f128;
}

static void f_code_解析功能块(std::vector<std::u16string>::iterator& it
                , std::vector<std::u16string>::iterator& end
				, bool 构建模块
				, S_导出模块* 模块
				){

	for( ; it != end; ++it){
		
		if(*it == u"fn"){
			++it;

			S_函数代码块 代码块;
			f_函数代码块解析(it, end, 代码块);
			if(g函数代码块.find(代码块.函数声明.函数名称) != g函数代码块.end()){
				g函数代码块[代码块.函数声明.函数名称] = 代码块;

				if(模块){
					模块->函数[代码块.函数声明.函数名称] = g函数代码块[代码块.函数声明.函数名称].函数声明;
				}
			}else{
				f_comInfo_输出错误(u"编译错误:已存在函数" + 代码块.函数声明.函数名称);
			}
			continue;
		} else if (*it == u"struct") {
			++it;

			S_结构代码块 代码块;
			f_结构代码块解析(it, end, 代码块, g以声明结构类型);
			if(g结构代码块.find(代码块.结构名称) != g结构代码块.end()){
				g结构代码块[代码块.结构名称] = 代码块;

				if(模块){
					模块->结构[代码块.结构名称] = g结构代码块[代码块.结构名称];
				}
			}else{
				f_comInfo_输出错误(u"编译错误:已存在结构" + 代码块.结构名称);
			}
			continue;
		} 
		//类型重定义
		else if (*it == u"typedef") {
			++it;
			continue;
		} 
		//成员函数
		else if (*it == u"impl") {
			++it;
			
			S_成员函数代码块* 代码块 = f_成员函数解析(it, end);
			g成员函数代码块[代码块->虚函数表名称] = *代码块;
			continue;
		} 
		//虚函数
		else if (*it == u"trait") {
			++it;

			S_虚函数代码块 代码块;
			f_虚函数代码解析(it, end, 代码块);
			if(g虚函数代码块.find(代码块.表名称) != g虚函数代码块.end()){
				g虚函数代码块[代码块.表名称] = 代码块;
			}else{
				std::cout<<"编译错误:虚函数列表以存在"<<代码块.表名称<<"\n";
			}
			continue;
		} 
		else if (*it == "import") {
			++it;
			//S_代码模块 代码块;
			f_解析导入模块代码(it, end, g导入模块);
			continue;
		}  else if (*it == "export") {
			++it;

			auto 模块名称 = *it;
			++it;

			auto& 子模块 = (*模块).子模块[模块名称];
			if(*it == "{") {
				auto s_it = 模块代码.begin();
				auto s_end = 模块代码.end();
				f_code_解析功能块(s_it, s_end, true, &子模块);
			} else {
				f_code_解析功能块(it, end, true, &子模块);
			}
		}

		auto 变量类型 = *it;
		if(g基础类型名称.find(变量类型) != g基础类型名称.end()){
			S_变量代码块 代码块;
			f_变量代码块解析(it, end, 代码块);
			g变量代码块[代码块.变量名称] = 代码块;

			if(模块){
				模块->变量[代码块.变量名称] = 变量类型;
			}
			continue;
		}

		if(g结构代码块.find(变量类型) != g结构代码块.end()){
			S_变量代码块 代码块;
			f_变量代码块解析(it, end, 代码块, g以声明结构类型);
			g变量代码块[代码块.变量名称] = 代码块;

			if(模块){
				模块->变量[代码块.变量名称] = 变量类型;
			}
			continue;
		}
		
		std::cout<<"编译错误:未知字符"<<*it<<"\n";
	}
}
static void f_code_块(const std::vector<std::u16string>& 词分割) {
	/*std::vector<std::u16string> 词分割;
    const char16_t* start = input.data();
    const char16_t* end = input.data() + input.size();
    while (start < end) {
        // 跳过前导分隔符
        while (start < end && std::wcschr(delimiters, *start) != nullptr) {
            ++start;
        }
        if (start == end) {
            break;
        }
        const char16_t* tokenStart = start;
        // 找到下一个分隔符
        while (start < end && std::wcschr(delimiters, *start) == nullptr) {
            ++start;
        }
        // 添加子字符串到结果中
        词分割.emplace_back(tokenStart, start);
    }*/
	//词分割.erase(std::remove_if(词分割.begin(), 词分割.end(), [](std::u16string& c) {
    //    return c.empty();
    //}), 词分割.end());
	
	auto end = 词分割.end();
	for(auto it = 词分割.begin(); it != end; ++it){
		if (*it == u"export") {
			++it;
			
			auto 模块名称 = *it;
			++it;

			if(*it == u"{") {
				auto 模块代码 = f_括号域(it, end, "{", "}");
				auto s_it = 模块代码.begin();
				auto s_end = 模块代码.end();
				f_code_解析功能块(s_it, s_end, true, &g代码导出模块[模块名称]);
			}
		} else {
			f_code_解析功能块(it, end, false, nullptr);
		}
	}
}

// 基于多个词分割宽字符字符串的高度优化版本
std::vector<std::u16string> splitByMultipleWordsOptimized(const std::u16string& input, const std::vector<std::u16string>& delimiters) {
    std::vector<std::u16string> result;
    size_t start = 0;

    // 构建查找表，存储每个分隔符的首字符及其对应的分隔符集合
    std::unordered_map<wchar_t, std::vector<std::u16string>> lookupTable;
    for (const auto& delimiter : delimiters) {
        if (!delimiter.empty()) {
            lookupTable[delimiter[0]].push_back(delimiter);
        }
    }

    while (start < input.length()) {
        size_t matchEnd = std::u16string::npos;
        size_t matchLen = 0;

        auto it = lookupTable.find(input[start]);
        if (it != lookupTable.end()) {
            // 只检查首字符匹配的分隔符
            for (const auto& delimiter : it->second) {
                if (input.compare(start, delimiter.length(), delimiter) == 0) {
                    matchEnd = start + delimiter.length();
                    matchLen = delimiter.length();
                    break;
                }
            }
        }

        if (matchEnd == std::u16string::npos) {
            // 如果当前位置不是分隔符的起始，继续查找下一个可能的分隔符
            size_t nextPossibleStart = input.find_first_of(lookupTable.begin()->first, start + 1);
            while (nextPossibleStart != std::u16string::npos) {
                it = lookupTable.find(input[nextPossibleStart]);
                if (it != lookupTable.end()) {
                    for (const auto& delimiter : it->second) {
                        if (input.compare(nextPossibleStart, delimiter.length(), delimiter) == 0) {
                            // 先添加从 start 到 nextPossibleStart 的子字符串
                            if (nextPossibleStart > start) {
                                result.push_back(input.substr(start, nextPossibleStart - start));
                            }
                            // 再添加分隔符本身
                            result.push_back(delimiter);
                            start = nextPossibleStart + delimiter.length();
                            matchEnd = std::u16string::npos; // 重置匹配状态
                            break;
                        }
                    }
                }
                if (matchEnd == std::u16string::npos) {
                    nextPossibleStart = input.find_first_of(lookupTable.begin()->first, nextPossibleStart + 1);
                } else {
                    break;
                }
            }

            if (nextPossibleStart == std::u16string::npos) {
                // 如果没有找到分隔符，将剩余部分添加到结果中
                result.push_back(input.substr(start));
                break;
            }
        } else {
            // 如果当前位置是分隔符的起始
            if (start > 0) {
                result.push_back(input.substr(0, start));
            }
            result.push_back(input.substr(start, matchLen));
            start = matchEnd;
        }
    }

    return result;
}

void f_code_解析节点代码(const std::u16string& code) {
	std::vector<std::u16string> delimiters = {
		u" ", u";", u"\b", u"{", u"}", u"(", u")", u"[", u"]", u".", u"->", u"++", u"--"
		, u"!", u"~", u"*", u"&", u"/", u"%", u"+", u"-"
		, u"<<", u">>"
		, u">", u"<", u">=", u"<=", u"==", u"!="
		, u"&", u"|", u"^", u"&&", u"||"
		, u"=", u"+=", u"-=", u"*=", u"/=", u"%=", u"<<=", u">>=", u"&=", u"|=", u"^="
		, u","
	};
	std::vector<std::u16string> 词分割 = splitByMultipleWordsOptimized(code, delimiters);

	for(auto& e : 词分割){
		e.erase(std::remove_if(e.begin(), e.end(), [](char16_t c) {
        	return c == u' ' || c == u'\b';
    	}), e.end());
	}

	//解析代码块
	f_code_块(词分割);

	//解析结构
	for(auto& e : g结构代码块){
		f_结构成员解析(e.second);
	}

	//解析函数
	f_函数实现解析();
	f_成员函数实现解析();
	f_虚函数实现解析();
	

}



